/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package modele;

import modele.realisateur.RealisateurCombinaisonSimple;
import modele.realisateur.RealisateurFull;
import modele.realisateur.InterfaceRealisateur;
import modele.combinaison.Combinaison;
import modele.combinaison.CombinaisonSimple;
import exception.CombinaisonInconnue;
import java.util.ArrayList;
import java.util.List;
import modele.combinaison.Chance;
import modele.combinaison.CombinaisonComplexe;
import modele.combinaison.Full;
import modele.combinaison.Multiple;
import modele.combinaison.Suite;
import modele.realisateur.RealisateurChance;
import modele.realisateur.RealisateurMultiple;
import modele.realisateur.RealisateurSuite;

/**
 * Classe IASequentielle : L'IA va réaliser les combinaisons automatiquement de
 * facon sequentielle. Elle commence par les combinaisons simple puis effectue
 * les combinaisons Complexes.
 * @author Florian MININ & Khémon BEH
 */
public class IASequentielle extends IA {

    private int combiActuelle;
    private List<Combinaison> ensembleCombi;

    /**
     * Constructeur
     * Il affecte le code joueur a l'IA
     * et initialise la liste des combinainsons a réaliser.
     * @param numJoueur
     */
    public IASequentielle(int numJoueur) {
        super(numJoueur);
        combiActuelle = 0;
        initialiseOrdreCombinaison();
    }

    public String jouerCoup(ModeleYamsInterface modele) throws CombinaisonInconnue {
        //Selectionner la combinaison a réaliser
        Combinaison combi = ensembleCombi.get(combiActuelle);

        //Essayer d'effectuer le meilleur score a partir des dés
        selectionSelonCombinaison(combi, modele);

        //On incrémente l'indice de la combi a réaliser pour
        //le prochain tour
        combiActuelle++;

        //Selectionner la combinaison
        return combi.getNomCombinaison();
    }

    /**
     * Initialise la liste de combinaison dans l'ordre ou elles
     * doivent être réalisée par l'IA.
     */
    private void initialiseOrdreCombinaison() {
        ensembleCombi = new ArrayList<Combinaison>();
        //Utilise l'itérateur défini dans la classe FeuiileScore
        for (Combinaison c : feuilleScore) {
            ensembleCombi.add(c);
        }
    }

    /**
     * Selectionne les dés selon la combinaison a réaliser
     * @param combi Combinaison correspondant a la combinaison a réaliser
     * @param modele modèle permettant d'effectuer les action sur le jeu
     */
    private void selectionSelonCombinaison(Combinaison combi, ModeleYamsInterface modele) {
        InterfaceRealisateur realisateur = null;
        //Si on a une combinaison simple
        //Il suffit de selectionner les dés dont la valeur est celle permettant
        //d'effectuer la combinaison et de relancer les dés tant qu'ils ne sont pas
        //tous écoulés
        if (combi.getTypeCombinaison().equals(CombinaisonSimple.COMBINAISON_SIMPLE)) {
            realisateur = new RealisateurCombinaisonSimple((CombinaisonSimple) combi, modele);
        }
        //C'est une combinaison complexe, on va regarder plus en détail
        else if(combi.getTypeCombinaison().equals(CombinaisonComplexe.COMBINAISON_COMPLEXE)){
            //Si c'est un multiple (Brelan, Carre, Yams)
            if(Multiple.class.isInstance(combi)){
                realisateur = new RealisateurMultiple((Multiple) combi,modele);
            }
            //Si c'est une suite (Petite suite, Grande suite)
            else if (Suite.class.isInstance(combi)){
                realisateur = new RealisateurSuite((Suite) combi, modele);
            } else if (combi.getNomCombinaison().equals(Full.COMBINAISON_FULL)) {
                realisateur = new RealisateurFull(modele);
            } else if (combi.getNomCombinaison().equals(Chance.COMBINAISON_CHANCE)) {
                realisateur = new RealisateurChance(modele);
            }
        }

        //On réalise la combinaison
        realisateur.realiseCombinaison();
    }
}
